/**
 *
 */
import Util;
import OpenApi;

import EndpointUtil;

extends OpenApi;

init(config: OpenApi.Config){
  super(config);
  @endpointRule = '';
  
  checkConfig(config);
  @endpoint = getEndpoint('hcs-mgw', @regionId, @endpointRule, @network, @suffix, @endpointMap, @endpoint);
}

function getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: map[string]string, endpoint: string) throws: string{
  if (!Util.empty(endpoint)) {
    return endpoint;
  }

  if (!Util.isUnset(endpointMap) && !Util.empty(endpointMap[regionId])) {
    return endpointMap[regionId];
  }
  return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
}
model CheckImportDataAddressRequest {
  mgwRegionId?: string(name='MgwRegionId'),
  vpcId?: string(name='VpcId'),
  vSwitchId?: string(name='VSwitchId'),
  addressType?: string(name='AddressType'),
  direction?: string(name='Direction'),
  domain?: string(name='Domain'),
  address?: string(name='Address'),
  subAddress?: string(name='SubAddress'),
  appid?: string(name='Appid'),
  listFilePath?: string(name='ListFilePath'),
  accessMethod?: string(name='AccessMethod'),
  accessProxy?: string(name='AccessProxy'),
  accessKeySecret?: string(name='AccessKeySecret'),
  accessKey?: string(name='AccessKey'),
  invDomain?: string(name='InvDomain'),
  invAccessKeyId?: string(name='InvAccessKeyId'),
  invSecretKey?: string(name='InvSecretKey'),
  invPath?: string(name='InvPath'),
  aliasName?: string(name='AliasName'),
}

model CheckImportDataAddressResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CheckImportDataAddressResponse = {
  headers: map[string]string(name='headers'),
  body: CheckImportDataAddressResponseBody(name='body'),
}

async function checkImportDataAddressWithOptions(request: CheckImportDataAddressRequest, runtime: Util.RuntimeOptions): CheckImportDataAddressResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CheckImportDataAddress', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function checkImportDataAddress(request: CheckImportDataAddressRequest): CheckImportDataAddressResponse {
  var runtime = new Util.RuntimeOptions{};
  return checkImportDataAddressWithOptions(request, runtime);
}

model CheckImportDataAddressExRequest {
  name?: string(name='Name'),
  direction?: string(name='Direction'),
}

model CheckImportDataAddressExResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CheckImportDataAddressExResponse = {
  headers: map[string]string(name='headers'),
  body: CheckImportDataAddressExResponseBody(name='body'),
}

async function checkImportDataAddressExWithOptions(request: CheckImportDataAddressExRequest, runtime: Util.RuntimeOptions): CheckImportDataAddressExResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CheckImportDataAddressEx', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function checkImportDataAddressEx(request: CheckImportDataAddressExRequest): CheckImportDataAddressExResponse {
  var runtime = new Util.RuntimeOptions{};
  return checkImportDataAddressExWithOptions(request, runtime);
}

model CheckMigrationLicenseRequest {
  license?: string(name='License'),
}

model CheckMigrationLicenseResponseBody = {
  success?: boolean(name='Success'),
  telephone?: string(name='Telephone'),
  message?: string(name='Message'),
  localAddress?: string(name='LocalAddress'),
  expirationDate?: long(name='ExpirationDate'),
  orderCreateDate?: long(name='OrderCreateDate'),
  requestId?: string(name='RequestId'),
  contact?: string(name='Contact'),
  size?: long(name='Size'),
  code?: string(name='Code'),
  licenseCreateDate?: long(name='LicenseCreateDate'),
  orderId?: long(name='OrderId'),
  uid?: long(name='Uid'),
}

model CheckMigrationLicenseResponse = {
  headers: map[string]string(name='headers'),
  body: CheckMigrationLicenseResponseBody(name='body'),
}

async function checkMigrationLicenseWithOptions(request: CheckMigrationLicenseRequest, runtime: Util.RuntimeOptions): CheckMigrationLicenseResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CheckMigrationLicense', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function checkMigrationLicense(request: CheckMigrationLicenseRequest): CheckMigrationLicenseResponse {
  var runtime = new Util.RuntimeOptions{};
  return checkMigrationLicenseWithOptions(request, runtime);
}

model CheckRoleRequest {
  roleName?: string(name='RoleName'),
}

model CheckRoleResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CheckRoleResponse = {
  headers: map[string]string(name='headers'),
  body: CheckRoleResponseBody(name='body'),
}

async function checkRoleWithOptions(request: CheckRoleRequest, runtime: Util.RuntimeOptions): CheckRoleResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CheckRole', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function checkRole(request: CheckRoleRequest): CheckRoleResponse {
  var runtime = new Util.RuntimeOptions{};
  return checkRoleWithOptions(request, runtime);
}

model CreateDataAddressRequest {
  mgwRegionId?: string(name='MgwRegionId'),
  vpcId?: string(name='VpcId'),
  vSwitchId?: string(name='VSwitchId'),
  name?: string(name='Name'),
  addressType?: string(name='AddressType'),
  enableAcceleration?: boolean(name='EnableAcceleration'),
  domain?: string(name='Domain'),
  address?: string(name='Address'),
  subAddress?: string(name='SubAddress'),
  appid?: string(name='Appid'),
  listFilePath?: string(name='ListFilePath'),
  accessMethod?: string(name='AccessMethod'),
  accessProxy?: string(name='AccessProxy'),
  accessVersion?: string(name='AccessVersion'),
  accessKeySecret?: string(name='AccessKeySecret'),
  accessKey?: string(name='AccessKey'),
  serverEncryption?: string(name='ServerEncryption'),
  aliasName?: string(name='AliasName'),
  invDomain?: string(name='InvDomain'),
  invAccessKeyId?: string(name='InvAccessKeyId'),
  invSecretKey?: string(name='InvSecretKey'),
  invPath?: string(name='InvPath'),
}

model CreateDataAddressResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  name?: string(name='Name'),
  success?: boolean(name='Success'),
}

model CreateDataAddressResponse = {
  headers: map[string]string(name='headers'),
  body: CreateDataAddressResponseBody(name='body'),
}

async function createDataAddressWithOptions(request: CreateDataAddressRequest, runtime: Util.RuntimeOptions): CreateDataAddressResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateDataAddress', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createDataAddress(request: CreateDataAddressRequest): CreateDataAddressResponse {
  var runtime = new Util.RuntimeOptions{};
  return createDataAddressWithOptions(request, runtime);
}

model CreateImportJobRequest {
  name?: string(name='Name'),
  totalObjectNum?: long(name='TotalObjectNum'),
  totalObjectSize?: string(name='TotalObjectSize'),
  expectedImportTime?: string(name='ExpectedImportTime'),
  incrementalMode?: boolean(name='IncrementalMode'),
  incrementalInterval?: int32(name='IncrementalInterval'),
  incrementalRepeatCount?: int32(name='IncrementalRepeatCount'),
  netFlowLimiter?: string(name='NetFlowLimiter'),
  isCustomizedInstance?: boolean(name='IsCustomizedInstance'),
  customizedInstances?: string(name='CustomizedInstances'),
  srcAddressRegionId?: string(name='SrcAddressRegionId'),
  srcAddressType?: string(name='SrcAddressType'),
  srcDomain?: string(name='SrcDomain'),
  srcAddress?: string(name='SrcAddress'),
  srcSubAddress?: string(name='SrcSubAddress'),
  srcAccessKeyId?: string(name='SrcAccessKeyId'),
  srcAccessKeySecret?: string(name='SrcAccessKeySecret'),
  srcAppid?: string(name='SrcAppid'),
  srcListFilePath?: string(name='SrcListFilePath'),
  destAddressRegionId?: string(name='DestAddressRegionId'),
  destAccessKeyId?: string(name='DestAccessKeyId'),
  destAccessKeySecret?: string(name='DestAccessKeySecret'),
  destBucket?: string(name='DestBucket'),
  destPrefix?: string(name='DestPrefix'),
}

model CreateImportJobResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  jobName?: string(name='JobName'),
  success?: boolean(name='Success'),
}

model CreateImportJobResponse = {
  headers: map[string]string(name='headers'),
  body: CreateImportJobResponseBody(name='body'),
}

async function createImportJobWithOptions(request: CreateImportJobRequest, runtime: Util.RuntimeOptions): CreateImportJobResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateImportJob', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createImportJob(request: CreateImportJobRequest): CreateImportJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return createImportJobWithOptions(request, runtime);
}

model CreateImportJobExRequest {
  name?: string(name='Name'),
  totalObjectNum?: long(name='TotalObjectNum'),
  totalObjectSize?: string(name='TotalObjectSize'),
  expectedImportTime?: string(name='ExpectedImportTime'),
  incrementalMode?: boolean(name='IncrementalMode'),
  incrementalInterval?: int32(name='IncrementalInterval'),
  incrementalRepeatCount?: int32(name='IncrementalRepeatCount'),
  netFlowLimiter?: string(name='NetFlowLimiter'),
  isCustomizedInstance?: boolean(name='IsCustomizedInstance'),
  customizedInstances?: string(name='CustomizedInstances'),
  lastModifiedTime?: long(name='LastModifiedTime'),
  aliasName?: string(name='AliasName'),
  includeDirOrFiles?: string(name='IncludeDirOrFiles'),
  excludeDirOrFiles?: string(name='ExcludeDirOrFiles'),
  filterMode?: string(name='FilterMode'),
  enableMultiVersioning?: boolean(name='EnableMultiVersioning'),
  coverageRule?: string(name='CoverageRule'),
  srcAddress?: string(name='SrcAddress'),
  destAddress?: string(name='DestAddress'),
}

model CreateImportJobExResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  jobName?: string(name='JobName'),
  success?: boolean(name='Success'),
}

model CreateImportJobExResponse = {
  headers: map[string]string(name='headers'),
  body: CreateImportJobExResponseBody(name='body'),
}

async function createImportJobExWithOptions(request: CreateImportJobExRequest, runtime: Util.RuntimeOptions): CreateImportJobExResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateImportJobEx', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createImportJobEx(request: CreateImportJobExRequest): CreateImportJobExResponse {
  var runtime = new Util.RuntimeOptions{};
  return createImportJobExWithOptions(request, runtime);
}

model CreateImportReportRequest {
  name?: string(name='Name'),
  lang?: string(name='Lang'),
}

model CreateImportReportResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  reportId?: string(name='ReportId'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateImportReportResponse = {
  headers: map[string]string(name='headers'),
  body: CreateImportReportResponseBody(name='body'),
}

async function createImportReportWithOptions(request: CreateImportReportRequest, runtime: Util.RuntimeOptions): CreateImportReportResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateImportReport', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createImportReport(request: CreateImportReportRequest): CreateImportReportResponse {
  var runtime = new Util.RuntimeOptions{};
  return createImportReportWithOptions(request, runtime);
}

model CreateJobRequest {
  name?: string(name='Name'),
  srcAddress?: string(name='SrcAddress'),
  destAddress?: string(name='DestAddress'),
  lastScanTime?: long(name='LastScanTime'),
  startDate?: long(name='StartDate'),
  intervalInSecond?: int32(name='IntervalInSecond'),
  repeatCount?: int32(name='RepeatCount'),
  groupFileSizeLimiter?: long(name='GroupFileSizeLimiter'),
  groupFileCountLimiter?: long(name='GroupFileCountLimiter'),
  speedTimeTableLimiter?: string(name='SpeedTimeTableLimiter'),
  noNewRunIfAnyRunning?: boolean(name='NoNewRunIfAnyRunning'),
  runImmediate?: boolean(name='RunImmediate'),
}

model CreateJobResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  jobId?: string(name='JobId'),
}

model CreateJobResponse = {
  headers: map[string]string(name='headers'),
  body: CreateJobResponseBody(name='body'),
}

async function createJobWithOptions(request: CreateJobRequest, runtime: Util.RuntimeOptions): CreateJobResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateJob', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createJob(request: CreateJobRequest): CreateJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return createJobWithOptions(request, runtime);
}

model CreateMigrationLicenseRequest {
  orderId?: string(name='OrderId'),
}

model CreateMigrationLicenseResponseBody = {
  license?: string(name='License'),
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateMigrationLicenseResponse = {
  headers: map[string]string(name='headers'),
  body: CreateMigrationLicenseResponseBody(name='body'),
}

async function createMigrationLicenseWithOptions(request: CreateMigrationLicenseRequest, runtime: Util.RuntimeOptions): CreateMigrationLicenseResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateMigrationLicense', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createMigrationLicense(request: CreateMigrationLicenseRequest): CreateMigrationLicenseResponse {
  var runtime = new Util.RuntimeOptions{};
  return createMigrationLicenseWithOptions(request, runtime);
}

model CreateMoverRequest {
  moverRegionId?: string(name='MoverRegionId'),
  vpcId?: string(name='VpcId'),
  vSwitchId?: string(name='VSwitchId'),
  scale?: string(name='Scale'),
}

model CreateMoverResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  moverId?: string(name='MoverId'),
  success?: boolean(name='Success'),
}

model CreateMoverResponse = {
  headers: map[string]string(name='headers'),
  body: CreateMoverResponseBody(name='body'),
}

async function createMoverWithOptions(request: CreateMoverRequest, runtime: Util.RuntimeOptions): CreateMoverResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateMover', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createMover(request: CreateMoverRequest): CreateMoverResponse {
  var runtime = new Util.RuntimeOptions{};
  return createMoverWithOptions(request, runtime);
}

model CreateOrderRequest {
  migSize?: int32(name='MigSize'),
  srcType?: string(name='SrcType'),
  destType?: string(name='destType'),
  toRegion?: string(name='ToRegion'),
  contactName?: string(name='ContactName'),
  phoneNumber?: string(name='PhoneNumber'),
  hasGigabitSwitch?: boolean(name='HasGigabitSwitch'),
  hasTenGigabitSwitch?: boolean(name='HasTenGigabitSwitch'),
  availableSwitchPortNum?: int32(name='AvailableSwitchPortNum'),
  hasElectricalPort?: boolean(name='HasElectricalPort'),
  hasFibreOpticalPort?: boolean(name='HasFibreOpticalPort'),
  has3U?: boolean(name='Has3U'),
  hasComputingNode?: boolean(name='HasComputingNode'),
  hasBrowser?: boolean(name='HasBrowser'),
  totalFileCount?: string(name='TotalFileCount'),
  averageFileSize?: string(name='AverageFileSize'),
}

model CreateOrderResponseBody = {
  serialNumber?: string(name='SerialNumber'),
  requestId?: string(name='RequestId'),
  orderId?: string(name='OrderId'),
}

model CreateOrderResponse = {
  headers: map[string]string(name='headers'),
  body: CreateOrderResponseBody(name='body'),
}

async function createOrderWithOptions(request: CreateOrderRequest, runtime: Util.RuntimeOptions): CreateOrderResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateOrder', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createOrder(request: CreateOrderRequest): CreateOrderResponse {
  var runtime = new Util.RuntimeOptions{};
  return createOrderWithOptions(request, runtime);
}

model CreateRemoteRequest {
  remoteName?: string(name='RemoteName'),
  regionId?: string(name='RegionId'),
  vpcId?: string(name='VpcId'),
  remoteType?: string(name='RemoteType'),
  remoteHost?: string(name='RemoteHost'),
  path?: string(name='Path'),
  mountType?: string(name='MountType'),
  userName?: string(name='UserName'),
  password?: string(name='Password'),
  mountPoint?: string(name='MountPoint'),
}

model CreateRemoteResponseBody = {
  remoteId?: string(name='RemoteId'),
  requestId?: string(name='RequestId'),
}

model CreateRemoteResponse = {
  headers: map[string]string(name='headers'),
  body: CreateRemoteResponseBody(name='body'),
}

async function createRemoteWithOptions(request: CreateRemoteRequest, runtime: Util.RuntimeOptions): CreateRemoteResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateRemote', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createRemote(request: CreateRemoteRequest): CreateRemoteResponse {
  var runtime = new Util.RuntimeOptions{};
  return createRemoteWithOptions(request, runtime);
}

model CreateVirtualClusterRequest {
  machineId?: string(name='MachineId'),
  masterPublicIp?: string(name='MasterPublicIp'),
  masterPrivateIp?: string(name='MasterPrivateIp'),
  port?: string(name='Port'),
  workersPrivateIp?: string(name='WorkersPrivateIp'),
  aliasName?: string(name='AliasName'),
  userNmae?: string(name='UserNmae'),
  password?: string(name='Password'),
}

model CreateVirtualClusterResponseBody = {
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  publicKey?: string(name='PublicKey'),
  code?: string(name='Code'),
  message?: string(name='Message'),
  clusterId?: string(name='ClusterId'),
}

model CreateVirtualClusterResponse = {
  headers: map[string]string(name='headers'),
  body: CreateVirtualClusterResponseBody(name='body'),
}

async function createVirtualClusterWithOptions(request: CreateVirtualClusterRequest, runtime: Util.RuntimeOptions): CreateVirtualClusterResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateVirtualCluster', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createVirtualCluster(request: CreateVirtualClusterRequest): CreateVirtualClusterResponse {
  var runtime = new Util.RuntimeOptions{};
  return createVirtualClusterWithOptions(request, runtime);
}

model DeleteDataAddressRequest {
  name?: string(name='Name'),
}

model DeleteDataAddressResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  name?: string(name='Name'),
  success?: boolean(name='Success'),
}

model DeleteDataAddressResponse = {
  headers: map[string]string(name='headers'),
  body: DeleteDataAddressResponseBody(name='body'),
}

async function deleteDataAddressWithOptions(request: DeleteDataAddressRequest, runtime: Util.RuntimeOptions): DeleteDataAddressResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DeleteDataAddress', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function deleteDataAddress(request: DeleteDataAddressRequest): DeleteDataAddressResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteDataAddressWithOptions(request, runtime);
}

model DeleteImportJobRequest {
  name?: string(name='Name'),
}

model DeleteImportJobResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  jobName?: string(name='JobName'),
  success?: boolean(name='Success'),
}

model DeleteImportJobResponse = {
  headers: map[string]string(name='headers'),
  body: DeleteImportJobResponseBody(name='body'),
}

async function deleteImportJobWithOptions(request: DeleteImportJobRequest, runtime: Util.RuntimeOptions): DeleteImportJobResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DeleteImportJob', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function deleteImportJob(request: DeleteImportJobRequest): DeleteImportJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteImportJobWithOptions(request, runtime);
}

model DeleteJobRequest {
  jobName?: string(name='JobName'),
}

model DeleteJobResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model DeleteJobResponse = {
  headers: map[string]string(name='headers'),
  body: DeleteJobResponseBody(name='body'),
}

async function deleteJobWithOptions(request: DeleteJobRequest, runtime: Util.RuntimeOptions): DeleteJobResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DeleteJob', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function deleteJob(request: DeleteJobRequest): DeleteJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteJobWithOptions(request, runtime);
}

model DeleteMoverRequest {
  moverId?: string(name='MoverId'),
}

model DeleteMoverResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model DeleteMoverResponse = {
  headers: map[string]string(name='headers'),
  body: DeleteMoverResponseBody(name='body'),
}

async function deleteMoverWithOptions(request: DeleteMoverRequest, runtime: Util.RuntimeOptions): DeleteMoverResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DeleteMover', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function deleteMover(request: DeleteMoverRequest): DeleteMoverResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteMoverWithOptions(request, runtime);
}

model DescribeBucketFoldersRequest {
  accessKey?: string(name='AccessKey'),
  accessKeySecret?: string(name='AccessKeySecret'),
  domain?: string(name='Domain'),
  bucket?: string(name='Bucket'),
  prefix?: string(name='Prefix'),
}

model DescribeBucketFoldersResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  folders?: {
    folder?: [ string ](name='folder')
  }(name='Folders'),
}

model DescribeBucketFoldersResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeBucketFoldersResponseBody(name='body'),
}

async function describeBucketFoldersWithOptions(request: DescribeBucketFoldersRequest, runtime: Util.RuntimeOptions): DescribeBucketFoldersResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeBucketFolders', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeBucketFolders(request: DescribeBucketFoldersRequest): DescribeBucketFoldersResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeBucketFoldersWithOptions(request, runtime);
}

model DescribeBucketsRequest {
  accessKey?: string(name='AccessKey'),
  accessKeySecret?: string(name='AccessKeySecret'),
  domain?: string(name='Domain'),
}

model DescribeBucketsResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  buckets?: {
    bucket?: [ string ](name='bucket')
  }(name='Buckets'),
}

model DescribeBucketsResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeBucketsResponseBody(name='body'),
}

async function describeBucketsWithOptions(request: DescribeBucketsRequest, runtime: Util.RuntimeOptions): DescribeBucketsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeBuckets', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeBuckets(request: DescribeBucketsRequest): DescribeBucketsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeBucketsWithOptions(request, runtime);
}

model DescribeDataAddressesRequest {
  mgwRegionId?: string(name='MgwRegionId'),
  vpcId?: string(name='VpcId'),
  vSwitchId?: string(name='VSwitchId'),
  addressType?: string(name='AddressType'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
}

model DescribeDataAddressesResponseBody = {
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  code?: string(name='Code'),
  message?: string(name='Message'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
  totalCount?: int32(name='TotalCount'),
  addresses?: {
    address?: [ 
    {
      vpcId?: string(name='VpcId'),
      status?: string(name='Status'),
      privateIp?: string(name='PrivateIp'),
      addressType?: string(name='AddressType'),
      aliAddress?: boolean(name='AliAddress'),
      accessMethod?: string(name='AccessMethod'),
      mgwRegionId?: string(name='MgwRegionId'),
      address?: string(name='Address'),
      subAddress?: string(name='SubAddress'),
      accessKeySecret?: string(name='AccessKeySecret'),
      accessProxy?: string(name='AccessProxy'),
      serverEncryption?: string(name='ServerEncryption'),
      name?: string(name='Name'),
      createdTime?: long(name='CreatedTime'),
      listFilePath?: string(name='ListFilePath'),
      domain?: string(name='Domain'),
      notes?: string(name='Notes'),
      aliUid?: long(name='AliUid'),
      enableAcceleration?: boolean(name='EnableAcceleration'),
      appid?: string(name='Appid'),
      accessVersion?: string(name='AccessVersion'),
      accessKeyId?: string(name='AccessKeyId'),
      vSwitchId?: string(name='VSwitchId'),
      elasticIp?: string(name='ElasticIp'),
      updatedTime?: long(name='UpdatedTime'),
      country?: string(name='Country'),
      aliasName?: string(name='AliasName'),
      detailedStatus?: string(name='DetailedStatus'),
    }
  ](name='Address')
  }(name='Addresses'),
}

model DescribeDataAddressesResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeDataAddressesResponseBody(name='body'),
}

async function describeDataAddressesWithOptions(request: DescribeDataAddressesRequest, runtime: Util.RuntimeOptions): DescribeDataAddressesResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeDataAddresses', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeDataAddresses(request: DescribeDataAddressesRequest): DescribeDataAddressesResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeDataAddressesWithOptions(request, runtime);
}

model DescribeImportJobsRequest {
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
}

model DescribeImportJobsResponseBody = {
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  code?: string(name='Code'),
  message?: string(name='Message'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
  totalCount?: int32(name='TotalCount'),
  jobs?: {
    job?: [ 
    {
      status?: string(name='Status'),
      finishTime?: long(name='FinishTime'),
      progress?: float(name='Progress'),
      cid?: string(name='Cid'),
      srcType?: string(name='SrcType'),
      aliUid?: long(name='AliUid'),
      srcAddress?: string(name='SrcAddress'),
      srcSubAddress?: string(name='SrcSubAddress'),
      jobId?: string(name='JobId'),
      jobRegionId?: string(name='JobRegionId'),
      name?: string(name='Name'),
      destBucket?: string(name='DestBucket'),
      createdTime?: long(name='CreatedTime'),
    }
  ](name='Job')
  }(name='Jobs'),
}

model DescribeImportJobsResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeImportJobsResponseBody(name='body'),
}

async function describeImportJobsWithOptions(request: DescribeImportJobsRequest, runtime: Util.RuntimeOptions): DescribeImportJobsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeImportJobs', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeImportJobs(request: DescribeImportJobsRequest): DescribeImportJobsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeImportJobsWithOptions(request, runtime);
}

model DescribeImportReportRequest {
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
  name?: string(name='Name'),
}

model DescribeImportReportResponseBody = {
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  code?: string(name='Code'),
  message?: string(name='Message'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
  totalCount?: int32(name='TotalCount'),
  reports?: {
    report?: [ 
    {
      status?: string(name='Status'),
      failedFileListPath?: string(name='FailedFileListPath'),
      importFileListPath?: string(name='ImportFileListPath'),
      description?: string(name='Description'),
      completedFileListPath?: string(name='CompletedFileListPath'),
      reportId?: string(name='ReportId'),
      createdTime?: long(name='CreatedTime'),
    }
  ](name='Report')
  }(name='Reports'),
}

model DescribeImportReportResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeImportReportResponseBody(name='body'),
}

async function describeImportReportWithOptions(request: DescribeImportReportRequest, runtime: Util.RuntimeOptions): DescribeImportReportResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeImportReport', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeImportReport(request: DescribeImportReportRequest): DescribeImportReportResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeImportReportWithOptions(request, runtime);
}

model DescribeJobsRequest {
  mgwRegionId?: string(name='MgwRegionId'),
  jobName?: string(name='JobName'),
  jobType?: string(name='JobType'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
}

model DescribeJobsResponseBody = {
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  code?: string(name='Code'),
  message?: string(name='Message'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
  totalCount?: int32(name='TotalCount'),
  jobs?: {
    job?: [ 
    {
      status?: string(name='Status'),
      destAddressName?: string(name='DestAddressName'),
      moverId?: string(name='MoverId'),
      groupFileCountLimiter?: long(name='GroupFileCountLimiter'),
      cid?: string(name='Cid'),
      jobType?: string(name='JobType'),
      srcAddressName?: string(name='SrcAddressName'),
      lastModifiedTime?: long(name='LastModifiedTime'),
      intervalInSecond?: int32(name='IntervalInSecond'),
      groupFileSizeLimiter?: long(name='GroupFileSizeLimiter'),
      speedTimeTableLimiter?: string(name='SpeedTimeTableLimiter'),
      incrementalMode?: boolean(name='IncrementalMode'),
      jobName?: string(name='JobName'),
      repeatCount?: int32(name='RepeatCount'),
      createdTime?: long(name='CreatedTime'),
      progress?: float(name='Progress'),
      archive?: boolean(name='Archive'),
      aliUid?: long(name='AliUid'),
      startDate?: long(name='StartDate'),
      regionId?: string(name='RegionId'),
      lastScanTime?: long(name='LastScanTime'),
      updatedTime?: long(name='UpdatedTime'),
      jobId?: string(name='JobId'),
      noNewRunIfAnyRunning?: boolean(name='NoNewRunIfAnyRunning'),
      detailedStatus?: string(name='DetailedStatus'),
      runImmediate?: boolean(name='RunImmediate'),
    }
  ](name='Job')
  }(name='Jobs'),
}

model DescribeJobsResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeJobsResponseBody(name='body'),
}

async function describeJobsWithOptions(request: DescribeJobsRequest, runtime: Util.RuntimeOptions): DescribeJobsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeJobs', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeJobs(request: DescribeJobsRequest): DescribeJobsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeJobsWithOptions(request, runtime);
}

model DescribeMigrationOrdersRequest {
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
}

model DescribeMigrationOrdersResponseBody = {
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  code?: string(name='Code'),
  message?: string(name='Message'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
  totalCount?: int32(name='TotalCount'),
  orders?: {
    order?: [ 
    {
      status?: string(name='Status'),
      hasHost?: boolean(name='HasHost'),
      telephone?: string(name='Telephone'),
      cloudStorageRegion?: string(name='CloudStorageRegion'),
      sourceType?: string(name='SourceType'),
      rentOrderId?: string(name='RentOrderId'),
      switchPortType?: string(name='SwitchPortType'),
      switchCapacity?: string(name='SwitchCapacity'),
      aliyunOrderId?: string(name='AliyunOrderId'),
      switchPort?: int32(name='SwitchPort'),
      createdTime?: long(name='CreatedTime'),
      rentDay?: int32(name='RentDay'),
      startDate?: string(name='StartDate'),
      aliyunInstanceId?: string(name='AliyunInstanceId'),
      localAddress?: string(name='LocalAddress'),
      cloudStorageType?: string(name='CloudStorageType'),
      p2pSize?: int32(name='P2pSize'),
      updatedTime?: long(name='UpdatedTime'),
      contact?: string(name='Contact'),
      size?: int32(name='Size'),
      deviceSpec?: string(name='DeviceSpec'),
      destType?: string(name='DestType'),
      saleMode?: string(name='SaleMode'),
      bracket?: string(name='Bracket'),
      aliyunUid?: long(name='AliyunUid'),
    }
  ](name='Order')
  }(name='Orders'),
}

model DescribeMigrationOrdersResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeMigrationOrdersResponseBody(name='body'),
}

async function describeMigrationOrdersWithOptions(request: DescribeMigrationOrdersRequest, runtime: Util.RuntimeOptions): DescribeMigrationOrdersResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeMigrationOrders', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeMigrationOrders(request: DescribeMigrationOrdersRequest): DescribeMigrationOrdersResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeMigrationOrdersWithOptions(request, runtime);
}

model DescribeMoverAttributeRequest {
  moverId?: string(name='MoverId'),
}

model DescribeMoverAttributeResponseBody = {
  status?: string(name='Status'),
  vpcId?: string(name='VpcId'),
  privateIp?: string(name='PrivateIp'),
  moverId?: string(name='MoverId'),
  success?: boolean(name='Success'),
  aliUid?: long(name='AliUid'),
  message?: string(name='Message'),
  serviceStatus?: string(name='ServiceStatus'),
  ecsInstanceId?: string(name='EcsInstanceId'),
  regionId?: string(name='RegionId'),
  password?: string(name='Password'),
  vSwitchId?: string(name='VSwitchId'),
  scale?: string(name='Scale'),
  requestId?: string(name='RequestId'),
  elasticIp?: string(name='ElasticIp'),
  updatedTime?: long(name='UpdatedTime'),
  publicIp?: string(name='PublicIp'),
  code?: string(name='Code'),
  note?: string(name='Note'),
  createdTime?: long(name='CreatedTime'),
}

model DescribeMoverAttributeResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeMoverAttributeResponseBody(name='body'),
}

async function describeMoverAttributeWithOptions(request: DescribeMoverAttributeRequest, runtime: Util.RuntimeOptions): DescribeMoverAttributeResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeMoverAttribute', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeMoverAttribute(request: DescribeMoverAttributeRequest): DescribeMoverAttributeResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeMoverAttributeWithOptions(request, runtime);
}

model DescribeMoversRequest {
  moverRegionId?: string(name='MoverRegionId'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
}

model DescribeMoversResponseBody = {
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  code?: string(name='Code'),
  message?: string(name='Message'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
  totalCount?: int32(name='TotalCount'),
  movers?: {
    gateway?: [ 
    {
      moverRegionId?: string(name='MoverRegionId'),
      vpcId?: string(name='VpcId'),
      status?: string(name='Status'),
      privateIp?: string(name='PrivateIp'),
      moverId?: string(name='MoverId'),
      aliUid?: long(name='AliUid'),
      ecsInstanceId?: string(name='EcsInstanceId'),
      serviceStatus?: string(name='ServiceStatus'),
      vSwitchId?: string(name='VSwitchId'),
      scale?: string(name='Scale'),
      elasticIp?: string(name='ElasticIp'),
      updatedTime?: long(name='UpdatedTime'),
      publicIp?: string(name='PublicIp'),
      note?: string(name='Note'),
      createdTime?: long(name='CreatedTime'),
    }
  ](name='Gateway')
  }(name='Movers'),
}

model DescribeMoversResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeMoversResponseBody(name='body'),
}

async function describeMoversWithOptions(request: DescribeMoversRequest, runtime: Util.RuntimeOptions): DescribeMoversResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeMovers', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeMovers(request: DescribeMoversRequest): DescribeMoversResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeMoversWithOptions(request, runtime);
}

model DescribeOfflineClusterRequest {
  alias?: string(name='Alias'),
}

model DescribeOfflineClusterResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  offline?: boolean(name='Offline'),
  success?: boolean(name='Success'),
  VClusters?: {
    VCluster?: [ 
    {
      vpc?: string(name='Vpc'),
      vSwitch?: string(name='VSwitch'),
      alias?: string(name='Alias'),
    }
  ](name='VCluster')
  }(name='VClusters'),
}

model DescribeOfflineClusterResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeOfflineClusterResponseBody(name='body'),
}

async function describeOfflineClusterWithOptions(request: DescribeOfflineClusterRequest, runtime: Util.RuntimeOptions): DescribeOfflineClusterResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeOfflineCluster', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeOfflineCluster(request: DescribeOfflineClusterRequest): DescribeOfflineClusterResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeOfflineClusterWithOptions(request, runtime);
}

model DescribeRegionsResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  regions?: {
    region?: [ 
    {
      localName?: string(name='LocalName'),
      regionId?: string(name='RegionId'),
    }
  ](name='Region')
  }(name='Regions'),
}

model DescribeRegionsResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeRegionsResponseBody(name='body'),
}

async function describeRegionsWithOptions(runtime: Util.RuntimeOptions): DescribeRegionsResponse {
  var req = new OpenApi.OpenApiRequest{};
  return doRPCRequest('DescribeRegions', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeRegions(): DescribeRegionsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeRegionsWithOptions(runtime);
}

model DescribeRemotesRequest {
  regionId?: string(name='RegionId'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
}

model DescribeRemotesResponseBody = {
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  code?: string(name='Code'),
  message?: string(name='Message'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
  totalCount?: int32(name='TotalCount'),
  movers?: {
    gateway?: [ 
    {
      vpcId?: string(name='VpcId'),
      remoteHost?: string(name='RemoteHost'),
      mountPoint?: string(name='MountPoint'),
      moverId?: string(name='MoverId'),
      mountType?: string(name='mountType'),
      remoteName?: string(name='RemoteName'),
      aliUid?: long(name='AliUid'),
      regionId?: string(name='RegionId'),
      remoteType?: string(name='RemoteType'),
      password?: string(name='Password'),
      updatedTime?: long(name='UpdatedTime'),
      path?: string(name='Path'),
      createdTime?: long(name='CreatedTime'),
    }
  ](name='Gateway')
  }(name='Movers'),
}

model DescribeRemotesResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeRemotesResponseBody(name='body'),
}

async function describeRemotesWithOptions(request: DescribeRemotesRequest, runtime: Util.RuntimeOptions): DescribeRemotesResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeRemotes', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeRemotes(request: DescribeRemotesRequest): DescribeRemotesResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeRemotesWithOptions(request, runtime);
}

model DescribeUserBusinessStatusResponseBody = {
  inDebtStatus?: string(name='InDebtStatus'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  code?: string(name='Code'),
  message?: string(name='Message'),
  businessStatus?: string(name='BusinessStatus'),
  riskControlStatus?: string(name='RiskControlStatus'),
}

model DescribeUserBusinessStatusResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeUserBusinessStatusResponseBody(name='body'),
}

async function describeUserBusinessStatusWithOptions(runtime: Util.RuntimeOptions): DescribeUserBusinessStatusResponse {
  var req = new OpenApi.OpenApiRequest{};
  return doRPCRequest('DescribeUserBusinessStatus', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeUserBusinessStatus(): DescribeUserBusinessStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeUserBusinessStatusWithOptions(runtime);
}

model DescribeUserOptionsResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  options?: {
    option?: [ string ](name='Option')
  }(name='Options'),
}

model DescribeUserOptionsResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeUserOptionsResponseBody(name='body'),
}

async function describeUserOptionsWithOptions(runtime: Util.RuntimeOptions): DescribeUserOptionsResponse {
  var req = new OpenApi.OpenApiRequest{};
  return doRPCRequest('DescribeUserOptions', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeUserOptions(): DescribeUserOptionsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeUserOptionsWithOptions(runtime);
}

model GetDataAddressRequest {
  name?: string(name='Name'),
}

model GetDataAddressResponseBody = {
  vpcId?: string(name='VpcId'),
  status?: string(name='Status'),
  privateIp?: string(name='PrivateIp'),
  message?: string(name='Message'),
  addressType?: string(name='AddressType'),
  accessMethod?: string(name='AccessMethod'),
  mgwRegionId?: string(name='MgwRegionId'),
  requestId?: string(name='RequestId'),
  code?: string(name='Code'),
  address?: string(name='Address'),
  subAddress?: string(name='SubAddress'),
  accessKeySecret?: string(name='AccessKeySecret'),
  accessProxy?: string(name='AccessProxy'),
  serverEncryption?: string(name='ServerEncryption'),
  name?: string(name='Name'),
  createdTime?: long(name='CreatedTime'),
  listFilePath?: string(name='ListFilePath'),
  domain?: string(name='Domain'),
  success?: boolean(name='Success'),
  notes?: string(name='Notes'),
  aliUid?: long(name='AliUid'),
  appid?: string(name='Appid'),
  accessKeyId?: string(name='AccessKeyId'),
  vSwitchId?: string(name='VSwitchId'),
  elasticIp?: string(name='ElasticIp'),
  updatedTime?: long(name='UpdatedTime'),
  detailedStatus?: string(name='DetailedStatus'),
}

model GetDataAddressResponse = {
  headers: map[string]string(name='headers'),
  body: GetDataAddressResponseBody(name='body'),
}

async function getDataAddressWithOptions(request: GetDataAddressRequest, runtime: Util.RuntimeOptions): GetDataAddressResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetDataAddress', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getDataAddress(request: GetDataAddressRequest): GetDataAddressResponse {
  var runtime = new Util.RuntimeOptions{};
  return getDataAddressWithOptions(request, runtime);
}

model GetImportJobDetailedStatusRequest {
  name?: string(name='Name'),
  lastMinutes?: int32(name='LastMinutes'),
}

model GetImportJobDetailedStatusResponseBody = {
  canRetry?: boolean(name='CanRetry'),
  qps?: string(name='Qps'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  useAcceleration?: boolean(name='UseAcceleration'),
  code?: string(name='Code'),
  message?: string(name='Message'),
  lastModifiedTime?: long(name='LastModifiedTime'),
  netflow?: string(name='Netflow'),
  job?: {
    status?: string(name='Status'),
    enableMultiVersioning?: boolean(name='EnableMultiVersioning'),
    isSkipExistFile?: string(name='IsSkipExistFile'),
    archive?: boolean(name='Archive'),
    name?: string(name='Name'),
    netFlowLimiter?: string(name='NetFlowLimiter'),
    excludeList?: [ string ](name='ExcludeList'),
    includeList?: [ string ](name='IncludeList'),
    source?: {
      status?: string(name='Status'),
      domain?: string(name='Domain'),
      notes?: string(name='Notes'),
      addressType?: string(name='AddressType'),
      appid?: string(name='Appid'),
      accessKeyId?: string(name='AccessKeyId'),
      address?: string(name='Address'),
      subAddress?: string(name='SubAddress'),
      detailedStatus?: string(name='DetailedStatus'),
      name?: string(name='Name'),
      createdTime?: long(name='CreatedTime'),
      listFilePath?: string(name='ListFilePath'),
    }(name='Source'),
    destination?: {
      status?: string(name='Status'),
      domain?: string(name='Domain'),
      notes?: string(name='Notes'),
      addressType?: string(name='AddressType'),
      appid?: string(name='Appid'),
      accessKeyId?: string(name='AccessKeyId'),
      address?: string(name='Address'),
      subAddress?: string(name='SubAddress'),
      detailedStatus?: string(name='DetailedStatus'),
      name?: string(name='Name'),
      createdTime?: long(name='CreatedTime'),
      listFilePath?: string(name='ListFilePath'),
    }(name='Destination'),
    schedule?: {
      finishedRepeatCount?: int32(name='FinishedRepeatCount'),
      incrementalMode?: boolean(name='IncrementalMode'),
      incrementalRepeatCount?: int32(name='IncrementalRepeatCount'),
      incrementalInterval?: int32(name='IncrementalInterval'),
      runImmediate?: boolean(name='RunImmediate'),
    }(name='Schedule'),
  }(name='Job'),
  storageProgress?: {
    progress?: float(name='Progress'),
    total?: string(name='Total'),
    completed?: string(name='Completed'),
  }(name='StorageProgress'),
  objectProgress?: {
    progress?: float(name='Progress'),
    failed?: long(name='Failed'),
    total?: long(name='Total'),
    completed?: long(name='Completed'),
  }(name='ObjectProgress'),
}

model GetImportJobDetailedStatusResponse = {
  headers: map[string]string(name='headers'),
  body: GetImportJobDetailedStatusResponseBody(name='body'),
}

async function getImportJobDetailedStatusWithOptions(request: GetImportJobDetailedStatusRequest, runtime: Util.RuntimeOptions): GetImportJobDetailedStatusResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetImportJobDetailedStatus', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getImportJobDetailedStatus(request: GetImportJobDetailedStatusRequest): GetImportJobDetailedStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return getImportJobDetailedStatusWithOptions(request, runtime);
}

model GetImportJobStatusRequest {
  name?: string(name='Name'),
}

model GetImportJobStatusResponseBody = {
  status?: string(name='Status'),
  canRetry?: boolean(name='CanRetry'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  code?: string(name='Code'),
  message?: string(name='Message'),
}

model GetImportJobStatusResponse = {
  headers: map[string]string(name='headers'),
  body: GetImportJobStatusResponseBody(name='body'),
}

async function getImportJobStatusWithOptions(request: GetImportJobStatusRequest, runtime: Util.RuntimeOptions): GetImportJobStatusResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetImportJobStatus', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getImportJobStatus(request: GetImportJobStatusRequest): GetImportJobStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return getImportJobStatusWithOptions(request, runtime);
}

model GetImportReportStatusRequest {
  name?: string(name='Name'),
  reportId?: string(name='ReportId'),
}

model GetImportReportStatusResponseBody = {
  status?: string(name='Status'),
  importFileListPath?: string(name='ImportFileListPath'),
  exportUrl?: string(name='ExportUrl'),
  success?: boolean(name='Success'),
  message?: string(name='Message'),
  reportId?: string(name='ReportId'),
  failedFileListPath?: string(name='FailedFileListPath'),
  requestId?: string(name='RequestId'),
  description?: string(name='Description'),
  completedFileListPath?: string(name='CompletedFileListPath'),
  code?: string(name='Code'),
  createdTime?: long(name='CreatedTime'),
}

model GetImportReportStatusResponse = {
  headers: map[string]string(name='headers'),
  body: GetImportReportStatusResponseBody(name='body'),
}

async function getImportReportStatusWithOptions(request: GetImportReportStatusRequest, runtime: Util.RuntimeOptions): GetImportReportStatusResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetImportReportStatus', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getImportReportStatus(request: GetImportReportStatusRequest): GetImportReportStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return getImportReportStatusWithOptions(request, runtime);
}

model GetLightningCubeInstallerUrlRequest {
  orderId?: long(name='OrderId'),
}

model GetLightningCubeInstallerUrlResponseBody = {
  code?: string(name='Code'),
  url?: string(name='Url'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetLightningCubeInstallerUrlResponse = {
  headers: map[string]string(name='headers'),
  body: GetLightningCubeInstallerUrlResponseBody(name='body'),
}

async function getLightningCubeInstallerUrlWithOptions(request: GetLightningCubeInstallerUrlRequest, runtime: Util.RuntimeOptions): GetLightningCubeInstallerUrlResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetLightningCubeInstallerUrl', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getLightningCubeInstallerUrl(request: GetLightningCubeInstallerUrlRequest): GetLightningCubeInstallerUrlResponse {
  var runtime = new Util.RuntimeOptions{};
  return getLightningCubeInstallerUrlWithOptions(request, runtime);
}

model GetSlsTokenResponseBody = {
  requestId?: string(name='RequestId'),
  securityToken?: string(name='SecurityToken'),
  success?: boolean(name='Success'),
  expiration?: string(name='Expiration'),
  code?: string(name='Code'),
  accessKeySecret?: string(name='AccessKeySecret'),
  message?: string(name='Message'),
  accessKeyId?: string(name='AccessKeyId'),
}

model GetSlsTokenResponse = {
  headers: map[string]string(name='headers'),
  body: GetSlsTokenResponseBody(name='body'),
}

async function getSlsTokenWithOptions(runtime: Util.RuntimeOptions): GetSlsTokenResponse {
  var req = new OpenApi.OpenApiRequest{};
  return doRPCRequest('GetSlsToken', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getSlsToken(): GetSlsTokenResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSlsTokenWithOptions(runtime);
}

model GetSupportImportDataAddressTypeResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  supportDataAddressTypeList?: {
    dataAddressType?: [ string ](name='dataAddressType')
  }(name='SupportDataAddressTypeList'),
}

model GetSupportImportDataAddressTypeResponse = {
  headers: map[string]string(name='headers'),
  body: GetSupportImportDataAddressTypeResponseBody(name='body'),
}

async function getSupportImportDataAddressTypeWithOptions(runtime: Util.RuntimeOptions): GetSupportImportDataAddressTypeResponse {
  var req = new OpenApi.OpenApiRequest{};
  return doRPCRequest('GetSupportImportDataAddressType', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getSupportImportDataAddressType(): GetSupportImportDataAddressTypeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSupportImportDataAddressTypeWithOptions(runtime);
}

model PayOrderCallbackRequest {
  data?: string(name='data'),
}

model PayOrderCallbackResponseBody = {
  code?: string(name='code'),
  requestId?: string(name='requestId'),
  message?: string(name='message'),
  data?: string(name='data'),
  success?: boolean(name='success'),
  synchro?: boolean(name='synchro'),
}

model PayOrderCallbackResponse = {
  headers: map[string]string(name='headers'),
  body: PayOrderCallbackResponseBody(name='body'),
}

async function payOrderCallbackWithOptions(request: PayOrderCallbackRequest, runtime: Util.RuntimeOptions): PayOrderCallbackResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('PayOrderCallback', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function payOrderCallback(request: PayOrderCallbackRequest): PayOrderCallbackResponse {
  var runtime = new Util.RuntimeOptions{};
  return payOrderCallbackWithOptions(request, runtime);
}

model RefundRequest {
  data?: string(name='data'),
}

model RefundResponseBody = {
  code?: string(name='code'),
  success?: boolean(name='success'),
  data?: string(name='data'),
  message?: string(name='message'),
  requestId?: string(name='requestId'),
}

model RefundResponse = {
  headers: map[string]string(name='headers'),
  body: RefundResponseBody(name='body'),
}

async function refundWithOptions(request: RefundRequest, runtime: Util.RuntimeOptions): RefundResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('Refund', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function refund(request: RefundRequest): RefundResponse {
  var runtime = new Util.RuntimeOptions{};
  return refundWithOptions(request, runtime);
}

model RetryDataAddressRequest {
  name?: string(name='Name'),
}

model RetryDataAddressResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  name?: string(name='Name'),
  success?: boolean(name='Success'),
}

model RetryDataAddressResponse = {
  headers: map[string]string(name='headers'),
  body: RetryDataAddressResponseBody(name='body'),
}

async function retryDataAddressWithOptions(request: RetryDataAddressRequest, runtime: Util.RuntimeOptions): RetryDataAddressResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('RetryDataAddress', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function retryDataAddress(request: RetryDataAddressRequest): RetryDataAddressResponse {
  var runtime = new Util.RuntimeOptions{};
  return retryDataAddressWithOptions(request, runtime);
}

model RetryImportJobRequest {
  name?: string(name='Name'),
}

model RetryImportJobResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  jobName?: string(name='JobName'),
  success?: boolean(name='Success'),
}

model RetryImportJobResponse = {
  headers: map[string]string(name='headers'),
  body: RetryImportJobResponseBody(name='body'),
}

async function retryImportJobWithOptions(request: RetryImportJobRequest, runtime: Util.RuntimeOptions): RetryImportJobResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('RetryImportJob', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function retryImportJob(request: RetryImportJobRequest): RetryImportJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return retryImportJobWithOptions(request, runtime);
}

model StartImportJobRequest {
  name?: string(name='Name'),
}

model StartImportJobResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  jobName?: string(name='JobName'),
  success?: boolean(name='Success'),
}

model StartImportJobResponse = {
  headers: map[string]string(name='headers'),
  body: StartImportJobResponseBody(name='body'),
}

async function startImportJobWithOptions(request: StartImportJobRequest, runtime: Util.RuntimeOptions): StartImportJobResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('StartImportJob', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function startImportJob(request: StartImportJobRequest): StartImportJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return startImportJobWithOptions(request, runtime);
}

model StartJobRequest {
  jobName?: string(name='JobName'),
}

model StartJobResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model StartJobResponse = {
  headers: map[string]string(name='headers'),
  body: StartJobResponseBody(name='body'),
}

async function startJobWithOptions(request: StartJobRequest, runtime: Util.RuntimeOptions): StartJobResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('StartJob', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function startJob(request: StartJobRequest): StartJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return startJobWithOptions(request, runtime);
}

model StopImportJobRequest {
  name?: string(name='Name'),
}

model StopImportJobResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  jobName?: string(name='JobName'),
  success?: boolean(name='Success'),
}

model StopImportJobResponse = {
  headers: map[string]string(name='headers'),
  body: StopImportJobResponseBody(name='body'),
}

async function stopImportJobWithOptions(request: StopImportJobRequest, runtime: Util.RuntimeOptions): StopImportJobResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('StopImportJob', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function stopImportJob(request: StopImportJobRequest): StopImportJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return stopImportJobWithOptions(request, runtime);
}

model StopJobRequest {
  jobName?: string(name='JobName'),
}

model StopJobResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model StopJobResponse = {
  headers: map[string]string(name='headers'),
  body: StopJobResponseBody(name='body'),
}

async function stopJobWithOptions(request: StopJobRequest, runtime: Util.RuntimeOptions): StopJobResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('StopJob', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function stopJob(request: StopJobRequest): StopJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return stopJobWithOptions(request, runtime);
}

model UpdateDataAddressRequest {
  mgwRegionId?: string(name='MgwRegionId'),
  vpcId?: string(name='VpcId'),
  vSwitchId?: string(name='VSwitchId'),
  name?: string(name='Name'),
  addressType?: string(name='AddressType'),
  domain?: string(name='Domain'),
  address?: string(name='Address'),
  subAddress?: string(name='SubAddress'),
  appid?: string(name='Appid'),
  listFilePath?: string(name='ListFilePath'),
  accessMethod?: string(name='AccessMethod'),
  accessProxy?: string(name='AccessProxy'),
  accessKeySecret?: string(name='AccessKeySecret'),
  accessKey?: string(name='AccessKey'),
  serverEncryption?: string(name='ServerEncryption'),
}

model UpdateDataAddressResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  name?: string(name='Name'),
  success?: boolean(name='Success'),
}

model UpdateDataAddressResponse = {
  headers: map[string]string(name='headers'),
  body: UpdateDataAddressResponseBody(name='body'),
}

async function updateDataAddressWithOptions(request: UpdateDataAddressRequest, runtime: Util.RuntimeOptions): UpdateDataAddressResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateDataAddress', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateDataAddress(request: UpdateDataAddressRequest): UpdateDataAddressResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateDataAddressWithOptions(request, runtime);
}

model UpdateImportJobRequest {
  name?: string(name='Name'),
  netflowLimiter?: string(name='NetflowLimiter'),
}

model UpdateImportJobResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  jobName?: string(name='JobName'),
  success?: boolean(name='Success'),
}

model UpdateImportJobResponse = {
  headers: map[string]string(name='headers'),
  body: UpdateImportJobResponseBody(name='body'),
}

async function updateImportJobWithOptions(request: UpdateImportJobRequest, runtime: Util.RuntimeOptions): UpdateImportJobResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateImportJob', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateImportJob(request: UpdateImportJobRequest): UpdateImportJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateImportJobWithOptions(request, runtime);
}

model UpdateMigrationStatusRequest {
  orderId?: string(name='OrderId'),
  status?: string(name='Status'),
}

model UpdateMigrationStatusResponseBody = {
  status?: string(name='Status'),
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UpdateMigrationStatusResponse = {
  headers: map[string]string(name='headers'),
  body: UpdateMigrationStatusResponseBody(name='body'),
}

async function updateMigrationStatusWithOptions(request: UpdateMigrationStatusRequest, runtime: Util.RuntimeOptions): UpdateMigrationStatusResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateMigrationStatus', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateMigrationStatus(request: UpdateMigrationStatusRequest): UpdateMigrationStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateMigrationStatusWithOptions(request, runtime);
}

model VerifyCssCreateOrderParamRequest {
  data?: string(name='data'),
}

model VerifyCssCreateOrderParamResponseBody = {
  code?: string(name='code'),
  requestId?: string(name='requestId'),
  message?: string(name='message'),
  data?: boolean(name='data'),
  success?: boolean(name='success'),
  synchro?: boolean(name='synchro'),
}

model VerifyCssCreateOrderParamResponse = {
  headers: map[string]string(name='headers'),
  body: VerifyCssCreateOrderParamResponseBody(name='body'),
}

async function verifyCssCreateOrderParamWithOptions(request: VerifyCssCreateOrderParamRequest, runtime: Util.RuntimeOptions): VerifyCssCreateOrderParamResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('VerifyCssCreateOrderParam', '2017-10-24', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function verifyCssCreateOrderParam(request: VerifyCssCreateOrderParamRequest): VerifyCssCreateOrderParamResponse {
  var runtime = new Util.RuntimeOptions{};
  return verifyCssCreateOrderParamWithOptions(request, runtime);
}

